Developer CD Series 2000 November: Tool Chest/Dev.CD Nov 00 TC Disk 1.toast/Sample Code/Graphics 2D/BrightContrastEngine/BCDemo.c

Text File | 2000-09-28 | 27.8 KB | 848 lines | [TEXT/CWIE]

//****************************************************************************************
// Brightness/Contrast Demo
//
// Written by Jack Fu, 09/1999
// Copyright 1999 by Apple Computer, Inc.
//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------------------
#include <AVComponents.h>

#include "BCEngine.h"


//----------------------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------------------
#define    SUPPORT_OLD_BC_ENGINES    1


//----------------------------------------------------------------------------------------
// Private Defines
//----------------------------------------------------------------------------------------
#define kSleepTime            10        // in ticks

#define kMBARResID            128
#define kAppleMenuResID        128
#define kFileMenuResID        129
#define kEditMenuResID        130

enum    // menu items for MENU kFileMenuResID
{
    kQuitMenuItem = 1
};

enum    // menu items for MENU kEditMenuResID
{
    kUndoMenuItem = 1
};

#define kDialogID                128
#define kComponentAlertID        129
#define kComponentOpenAlertID    130
#define kComponentTargetAlertID    131
#define kComponentMiscAlertID    132
#define kDMAlertID                133

enum    // dialog items for DITL (ID = kDialogID )
{
    kContrastTextItem = 1,
    kContrastSliderItem,
    kBrightnessTextItem,
    kBrightnessSliderItem,
    kContrast0PctTextItem,
    kContrast100PctTextItem,
    kBrightness0PctTextItem,
    kBrightness100PctTextItem
};


//----------------------------------------------------------------------------------------
// Private Prototypes
//----------------------------------------------------------------------------------------
typedef struct OurDMNotifyData
{
    ComponentInstance    engine;
    DialogPtr            dp;
    ControlHandle        brightnessCtl;
    ControlHandle        contrastCtl;
} OurDMNotifyData, *OurDMNotifyDataPtr, **OurDMNotifyDataHdl;


//----------------------------------------------------------------------------------------
// Private Prototypes
//----------------------------------------------------------------------------------------
OSErr         InitializeApp                (void);
void         CleanUpApp                    (OurDMNotifyDataPtr dataP);

DialogPtr     SetupDialog                    (ComponentInstance engine, OurDMNotifyDataPtr dataP);
OSErr         RunEventLoop                (DialogPtr dp, ComponentInstance engine);
OSErr         HandleMouseDown                (EventRecord* theEvent, DialogPtr dp, ComponentInstance engine, Boolean *handled);
OSErr         HandleMenuSelect            (EventRecord* theEvent, ComponentInstance engine, Boolean *handled);

OSErr         OpenEngine                    (ComponentInstance *engine);
OSErr         FindBCEngine                (AVIDType displayID, Component *theEnginePtr);
OSErr         ResetSettings                (ComponentInstance engine, short brightness, short contrast);
OSErr         UpdateSliders                (OurDMNotifyDataPtr dataP);
static pascal void BCTargetIterator        (void* userData, DMListIndexType itemIndex, DMComponentListEntryPtr listInfo);

pascal OSErr AEOpenHandler                (AppleEvent *messagein, AppleEvent *reply, long refln);
pascal OSErr AEQuitHandler                (AppleEvent *messagein, AppleEvent *reply, long refIn);

pascal void ContrastActionProc            (ControlHandle theControl, short partCode);
pascal void BrightnessActionProc        (ControlHandle theControl, short partCode);
pascal void BrightnessContrastNotify    (void* userData, short theMessage, void* notifyData);


//----------------------------------------------------------------------------------------
// Globals
//----------------------------------------------------------------------------------------
Boolean                        gTimeToQuit             = false;
ControlActionUPP            gBrightnessSliderUPP     = NULL;
ControlActionUPP            gContrastSliderUPP         = NULL;
DMExtendedNotificationUPP    gDMNotifyUPP            = NULL;
DisplayIDType                gOurDisplayID;
short                        gInitialBrightness;
short                        gInitialContrast;


//****************************************************************************************
// main
//
//----------------------------------------------------------------------------------------
int main (void)
{
    OSErr                result         = noErr;
    DialogPtr            myDialog     = NULL;
    ComponentInstance    engine;
    OurDMNotifyData        data;

    result = InitializeApp();

    //--- First, we must be able to find a brightness/contrast engine ---
    if ( result == noErr )
        result = OpenEngine( &engine );

    //--- Store the initial engine settings in case we want to undo later ---
    if ( result == noErr )
    {
        result = ContrastEngineGetBrightness( engine, &gInitialBrightness );
        if ( result == noErr )
            result = ContrastEngineGetContrast( engine, &gInitialContrast );
    }

    if ( result == noErr )
    {
        //--- Bring up our dialog window ----------------------------------
        myDialog = SetupDialog( engine, &data );

        //--- Do the main loop -------------------------------------------
        if ( myDialog != NULL )
            result = RunEventLoop( myDialog, engine );
    }

    CleanUpApp( &data );

    return result;
}

//****************************************************************************************
// InitializeApp
//
//----------------------------------------------------------------------------------------
OSErr InitializeApp (void)
{
    OSErr        result             = noErr;
    Handle        myMenu             = NULL;
    MenuHandle    appleMenuHandle = NULL;

    //--- Initialize all needed managers ---------------------------------
    InitGraf(&qd.thePort);
    InitFonts();
    InitWindows();
    InitMenus();
    TEInit();
    InitDialogs(nil);
    InitCursor();

    //--- Required Suite -------------------------------------------------
    result = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc(AEOpenHandler), 0L, false );
    if ( result == noErr )
        result = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerProc(AEOpenHandler), 0L, false );
    if ( result == noErr )
        result = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerProc(AEOpenHandler), 0L, false );
    if ( result == noErr )
        result = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc(AEQuitHandler), 0L, false );

    //--- Initialize the Menu Bar ----------------------------------------
    if ( result == noErr )
    {
        myMenu = GetNewMBar( kMBARResID );
        SetMenuBar( myMenu );
        appleMenuHandle = GetMenuHandle( kAppleMenuResID );
        AppendResMenu( appleMenuHandle, 'DRVR' );

        //--- When all is said and done, draw the menu ------------
        DrawMenuBar();
    }

    return result;
}

//****************************************************************************************
// CleanUpApp
//
//----------------------------------------------------------------------------------------
void CleanUpApp (OurDMNotifyDataPtr dataP)
{
    ProcessSerialNumber    currentPSN;

    //--- Remove Display Manager's notification proc -------------
    GetCurrentProcess( ¤tPSN );
    DMRemoveExtendedNotifyProc( gDMNotifyUPP, (void*) dataP, ¤tPSN, (unsigned short) NULL);
    DisposeRoutineDescriptor( gDMNotifyUPP );

    //--- Dispose the other routine descriptors ------------------
    DisposeRoutineDescriptor( gBrightnessSliderUPP );
    DisposeRoutineDescriptor( gContrastSliderUPP );

    return;
}

//****************************************************************************************
// AEOpenHandler
//
//  - used to handle opendoc, openapp, and printdoc AE events
//----------------------------------------------------------------------------------------
pascal OSErr AEOpenHandler (AppleEvent *messagein, AppleEvent *reply, long refIn)
{
#pragma unused (messagein, refIn, reply)

    return noErr;
}

//****************************************************************************************
// AEQuitHandler
//
//
//----------------------------------------------------------------------------------------
pascal OSErr AEQuitHandler (AppleEvent *messagein, AppleEvent *reply, long refIn)
{
#pragma unused (messagein, refIn, reply)

    gTimeToQuit = true;
    return noErr;
}


//****************************************************************************************
#pragma mark -
#pragma mark • Event Handling Routines
#pragma mark -
//****************************************************************************************

//****************************************************************************************
// RunEventLoop
//
//
//----------------------------------------------------------------------------------------
OSErr RunEventLoop (DialogPtr dp, ComponentInstance engine)
{
    OSErr            err         = noErr;
    Boolean            handled     = false;
    EventRecord        theEvent;
    short            itemHit;

    while ( err == noErr && !gTimeToQuit )
    {
        if ( WaitNextEvent(everyEvent, &theEvent, kSleepTime, NULL) )
        {
            //--- Handle events ------------------------------------
            switch (theEvent.what)
            {
                case updateEvt:
                case activateEvt:
                case mouseDown:
                    if ( IsDialogEvent(&theEvent) )
                        DialogSelect(&theEvent, &dp, &itemHit);
                    else
                        err = HandleMouseDown( &theEvent, dp, engine, &handled );
                    break;

                case keyDown:
                case autoKey:
                    //--- We only care about Command-key shortcuts -----
                    if ( theEvent.modifiers & cmdKey )
                        err = HandleMenuSelect( &theEvent, engine, &handled );
                    break;

                case kHighLevelEvent:
                    err = AEProcessAppleEvent( &theEvent );
                    handled = true;
                    break;

                case diskEvt:
                case osEvt:
                default:
                    break;
            }
        }
    }

    return err;
}

//****************************************************************************************
// HandleMouseDown
//
//----------------------------------------------------------------------------------------
OSErr HandleMouseDown (EventRecord* theEvent, DialogPtr dp, ComponentInstance engine, Boolean *handled)
{
    OSErr            result         = noErr;
    Boolean            wasActive     = true;
    WindowPtr        theWindow;
    short            partCode;

    //--- Figure out which window was hit -------------------------
    partCode = FindWindow( theEvent->where, &theWindow );

    //--- Figure out where the window was hit ---------------------
    switch( partCode )
    {
        case inMenuBar:
            result = HandleMenuSelect( theEvent, engine, handled );
            break;

        case inSysWindow:
            SystemClick( theEvent, theWindow );
            *handled = true;
            break;

        case inDrag:
            {
                //--- Allow the user to drag our window around --------
                RgnHandle screenbounds = GetGrayRgn();
                DragWindow( (WindowPtr)dp, theEvent->where, &(*screenbounds)->rgnBBox );
            }
            break;

        case inDesk:
        case inGrow:
        case inContent:
        case inGoAway:
        case inZoomIn:
        case inZoomOut:
            break;

    }

    return result;
}

//****************************************************************************************
// HandleMenuSelect
//
//----------------------------------------------------------------------------------------
OSErr HandleMenuSelect (EventRecord* theEvent, ComponentInstance engine, Boolean *handled)
{
    OSErr    result = noErr;
    long    menuVal;

    //--- Translate event to something useful -------------------
    if ( theEvent->modifiers & cmdKey )
        menuVal = MenuKey( theEvent->message & charCodeMask );
    else
        menuVal = MenuSelect( theEvent->where );

    if ( HiWord( menuVal ) == kFileMenuResID && LoWord( menuVal ) == kQuitMenuItem )
    {
        //--- The user has hit Command-Q -----------------------
        gTimeToQuit = true;
        *handled = true;
    }
    else if ( HiWord( menuVal ) == kEditMenuResID && LoWord( menuVal ) == kUndoMenuItem )
    {
        //--- The user has hit Command-Z to undo: reset the contrast/brightness
        //--- settings to what we started with
        result = ResetSettings( engine, gInitialBrightness, gInitialContrast );
    }

    //--- Un-hilite the menu bar --------------------------------
    HiliteMenu( 0 );

    return result;
}

//****************************************************************************************
// UpdateSliders
//
//
//----------------------------------------------------------------------------------------
OSErr UpdateSliders (OurDMNotifyDataPtr dataP)
{
    OSErr    result = noErr;
    short    value;

    //--- Get the current brightness and set the brightness slider control ----
    result = ContrastEngineGetBrightness( dataP->engine, &value );
    if ( result == noErr )
    {
        SetControlValue( dataP->brightnessCtl, value );

        //--- Get the current contrast and set the contrast slider control -----
        result = ContrastEngineGetContrast( dataP->engine, &value );
        if ( result == noErr )
            SetControlValue( dataP->contrastCtl, value );
    }

    return result;
}


//****************************************************************************************
#pragma mark -
#pragma mark • Engine Routines
#pragma mark -
//****************************************************************************************

//****************************************************************************************
// OpenEngine
//
//
//----------------------------------------------------------------------------------------
OSErr OpenEngine (ComponentInstance *engine)
{
    OSErr            result         = noErr;
    GDHandle        aGDevice     = NULL;
    DisplayIDType    displayID     = kInvalidDisplayID;
    Component        bcEngine;

    //--- In the demo, we only mess with the main GDevice. In general, one could
    //--- use a combination of DMGetFirstScreenDevice and DMGetNextScreenDevice
    //--- (see Displays.h) to go through the exhaustive list of displays.
    aGDevice = GetMainDevice();
    if ( aGDevice != NULL )
    {
        //--- Get the DisplayID for this GDevice --------------------
        result = DMGetDisplayIDByGDevice( aGDevice, &displayID, false );
    }

    //--- Check for Display Manager errors
    if ( aGDevice == NULL || result != noErr )
    {
        StopAlert( kDMAlertID, NULL );
        return -1;
    }

    //--- Find an engine for this DisplayID -------------------------------
    gOurDisplayID = displayID;
    result = FindBCEngine( displayID, &bcEngine );
    if ( result != noErr )
    {
        StopAlert( kComponentAlertID, NULL );
        return -2;
    }

    //--- Open the engine --------------------------------------------------
    *engine = OpenComponent( bcEngine );
    if ( *engine == NULL )
    {
        StopAlert( kComponentOpenAlertID, NULL );
        return -3;
    }

    //--- Tell the engine which display device we want it to control ----------
    result = AVEngineComponentTargetDevice( *engine, displayID );
    if ( result != noErr )
    {
        StopAlert( kComponentTargetAlertID, NULL );
        return -4;
    }

    return result;
}

//****************************************************************************************
// SetupDialog
//
//
//----------------------------------------------------------------------------------------
DialogPtr SetupDialog (ComponentInstance engine, OurDMNotifyDataPtr dataP)
{
    OSErr                    result                     = noErr;
    DialogPtr                dp                         = NULL;
    ControlHandle            brightnessSliderCtl;
    ControlHandle            contrastSliderCtl;
    ProcessSerialNumber        currentPSN;

    //--- Grab our dialog from resource -------------------------
    dp = GetNewDialog( kDialogID, NULL, (WindowPtr) -1 );

    if ( ResError() == noErr && dp != NULL )
    {
        short             itemType;
        Rect            itemRect;
        Handle            itemHdl;
        short            min, max, value;

        SetPort( (GrafPtr) dp );

        //--- Set up contrast slider ------------------------------
        gContrastSliderUPP = NewControlActionProc( ContrastActionProc );

        GetDialogItem( dp, kContrastSliderItem, &itemType, &itemHdl, &itemRect );
        result = ContrastEngineGetContrastRange( engine, &min, &max );
        if ( result == noErr )
        {
            result = ContrastEngineGetContrast( engine, &value);
            if ( result == noErr )
            {
                //--- Get and use the system slider procs - this is for 8.0 and later only.
                contrastSliderCtl = NewControl ( dp,
                                                 &itemRect,
                                                 "\p",
                                                 false,
                                                 value,
                                                 min,
                                                 max,
                                                 kControlSliderProc + kControlSliderLiveFeedback + kControlSliderNonDirectional,
                                                 0);

                //--- Associate this control with our dialog and set up the control action proc
                SetDialogItem( dp, kContrastSliderItem, ctrlItem, (Handle) contrastSliderCtl, &itemRect );
                SetControlReference( contrastSliderCtl, (long) engine );
                SetControlAction( contrastSliderCtl, gContrastSliderUPP );
                ShowControl( contrastSliderCtl );
            }
        }
        if ( result != noErr )
        {
            StopAlert( kComponentMiscAlertID, NULL );
            return NULL;
        }

        //--- Set up brightness slider ------------------------------
        gBrightnessSliderUPP = NewControlActionProc( BrightnessActionProc );

        GetDialogItem( dp, kBrightnessSliderItem, &itemType, &itemHdl, &itemRect );
        result = ContrastEngineGetBrightnessRange( engine, &min, &max );
        if ( result == noErr )
        {
            result = ContrastEngineGetBrightness( engine, &value);
            if ( result == noErr )
            {
                //--- Get and use the system slider procs - this is for 8.0 and later only.
                brightnessSliderCtl = NewControl ( dp,
                                                   &itemRect,
                                                   "\p",
                                                   false,
                                                   value,
                                                      min,
                                                      max,
                                                      kControlSliderProc + kControlSliderLiveFeedback + kControlSliderNonDirectional,
                                                      0);

                //--- Associate this control with our dialog and set up the control action proc
                SetDialogItem( dp, kBrightnessSliderItem, ctrlItem, (Handle) brightnessSliderCtl, &itemRect);
                SetControlReference( brightnessSliderCtl, (long) engine );
                SetControlAction( brightnessSliderCtl, gBrightnessSliderUPP );
                ShowControl( brightnessSliderCtl );
            }
        }
        if ( result != noErr )
        {
            StopAlert( kComponentMiscAlertID, NULL );
            return NULL;
        }

        //--- Set up some stuff used by the notification function (i.e. when Display Mgr calls us)
        dataP->engine             = engine;
        dataP->dp                 = dp;
        dataP->brightnessCtl     = brightnessSliderCtl;
        dataP->contrastCtl         = contrastSliderCtl;

        //----------------------------------------------------------------------
        // Register for notification with the Display Manager so we can update
        // the sliders if brightness or contrast changes outside of our demo app.
        // Display Mgr will call us whenever brightness or contrast change so
        // we can update our sliders to reflect the actual values.
        //----------------------------------------------------------------------
        GetCurrentProcess( ¤tPSN );
        gDMNotifyUPP = NewDMExtendedNotificationProc( BrightnessContrastNotify );
        DMRegisterExtendedNotifyProc( gDMNotifyUPP, (void*) dataP, (unsigned short) NULL, ¤tPSN );

        //--- show our dialog box ---------------------------------
        ShowWindow( (WindowPtr) dp );
    }

    return dp;
}

//****************************************************************************************
// ResetSettings
//
//
//----------------------------------------------------------------------------------------
OSErr ResetSettings (ComponentInstance engine, short brightness, short contrast)
{
    OSErr    result = noErr;

    //--- Call the engine to reset the values for brightness and contrast.
    //--- We won't redraw the sliders here: Display Mgr will notify us later
    //--- so we can update the sliders later.
    result = ContrastEngineSetBrightness( engine, brightness );
    if ( result == noErr )
        result = ContrastEngineSetContrast( engine, contrast );

    if ( result != noErr )
        StopAlert( kComponentMiscAlertID, NULL );

    return result;
}

//****************************************************************************************
// FindBCEngine
//
//
//----------------------------------------------------------------------------------------
OSErr FindBCEngine (AVIDType displayID, Component *theEnginePtr)
{
    ComponentResult                result;
    DMListType                    engineList             = NULL;
    DMListIndexType                engineCount         = 0;
    DMComponentListIteratorUPP    theListIteratorUPP;

    //--- Pre-init the returned engine ptr ------------------------------
    *theEnginePtr = NULL;

#if SUPPORT_OLD_BC_ENGINES

    //-------------------------------------------------------------------
    // Currently, there are two types of brightness/contrast engines:
    //
    //   kContrastEngineComponentSubType
    //   kOldContrastEngineComponentSubType
    //
    // The first engine type is more general and can handle all apple
    // displays. The second engine type is meant to be used only with
    // macs that have built-in displays (like the iMac or the all-in-one
    // PowerMac G3). Currently, the former engine type cannot control
    // brightness/contrast on the built-in monitors.
    //
    // However, the latter is being phased out, and in a little while
    // we will provide a single engine type (i.e. kContrastEngineComponentSubType)
    // that can handle all apple displays -- built-in or otherwise. At that
    // point in time, one would only need to ask for and use one single
    // engine type.
    //
    // In the meantime, we can find an appropriate engine to use with
    // any given GDevice by looking for kOldContrastEngineComponentSubType
    // first. If an engine is returned by DMNewAVEngineList, we'll know
    // that the given GDevice is a built-in display. If no engines are
    // returned, then we know that we need to look for the more general
    // kContrastEngineComponentSubType engine type.
    //
    // Note that Apple's brightness/contrast engines do not work with
    // third-party displays.
    //-------------------------------------------------------------------

    result = DMNewAVEngineList( displayID,
                                kOldContrastEngineComponentSubType,
                                kMinimumFidelity,
                                0,
                                0,
                                &engineCount,
                                &engineList );
#endif

    //-------------------------------------------------------------------
    // DMNewAVEngineList()
    //
    //   DMNewAVEngineList is a Display Manager call that can be used to
    //   find engines that will work with a particular display. For example,
    //   in this demo app we are interested in finding a brightness/contrast
    //   engine that will work with the main GDevice.
    //
    //   Display Manager will only return engines matching the caller's
    //   requirements. Here are some brief descriptions of each parameter:
    //
    //
    //    DMNewAVEngineList ( DisplayIDType         displayID,
    //                         ResType             engineType,
    //                         DMFidelityType         minimumFidelity,
    //                         unsigned long        engineListFlags,
    //                         unsigned long        reserved,
    //                         DMListIndexType *    engineCount,
    //                         DMListType *        engineList )
    //
    //
    //  displayID - the display ID of the display that we want an engine for.
    //
    //  engineType - the type of engine that we are interested in. For
    //               brightness/contrast engines, use the constant
    //                 "kContrastEngineComponentSubType", which will return
    //                 engines that can talk to Apple's displays. Currently,
    //                 you'll need to specify "kOldContrastEngineComponentSubType"
    //                 if you want an engine to control built-in displays like
    //                 on the iMac or the all-in-one PowerMac G3. In the near
    //                 future, one will be able to specify just one constant
    //                 (kContrastEngineComponentSubType) and get the best
    //                 brightness/contrast engine that'll work with the given
    //                 display ID without using two constants.
    //
    //  minimumFidelity - an arbitrary number used by engines to tell Display
    //                      Manager how well each engine works with the given
    //                      display. Display Manager will not return any engine
    //                      that has a lower fidelity than specified in this
    //                      parameter. In general, use "kMinimumFidelity".
    //
    //  engineListFlags - set to 0.
    //
    //  reserved - set to 0.
    //
    //  engineCount - returns the number of engines found.
    //
    //  engineList - a list of engines that match the requirements. The first
    //                 engine will be the best one to use. See code below for
    //                 grabbing the first engine.
    //
    //-------------------------------------------------------------------

    if ( engineCount <= 0 )
    {
        //--- We couldn't find any old brightness/contrast engines. So
        //--- we'll just look for and use the normal one.

        //--- Clean up the engine list if necessary
        if ( engineList != NULL )
            DMDisposeList( engineList );

        //--- Ask DisplayMgr for a list of brightness/contrast engines ------
        //--- NOTE: DM _only_ returns engines for the given displayID -------
        result = DMNewAVEngineList( displayID,
                                    kContrastEngineComponentSubType,
                                    kMinimumFidelity,
                                    0,
                                    0,
                                    &engineCount,
                                    &engineList);
    }

    //--- Did we get an engine? -----------------------------------------
    if ( result == noErr && engineCount > 0 )
    {
        theListIteratorUPP = NewDMComponentListIteratorProc(BCTargetIterator);

        //--- Get the first engine in list ------------------------------
        result = DMGetIndexedComponentFromList( engineList, 0, 0, theListIteratorUPP, theEnginePtr );

        //--- Get rid of the list routine descriptor
        DisposeRoutineDescriptor(theListIteratorUPP);
    }
    else
    {
        result = -1;
    }

    //--- Dispose of the list --------------------------------------------
    if ( engineList != NULL )
        DMDisposeList( engineList );

    return result;
}

//****************************************************************************************
// BCTargetIterator
//
//
//----------------------------------------------------------------------------------------
static pascal void BCTargetIterator (void* userData, DMListIndexType itemIndex, DMComponentListEntryPtr listInfo)
{
    #pragma unused(itemIndex)

    *(Component *)userData = listInfo->itemComponent;
}

//****************************************************************************************
// BrightnessActionProc
//
//
//----------------------------------------------------------------------------------------
pascal void BrightnessActionProc (ControlHandle theControl, short partCode)
{
#pragma unused (partCode)

    ComponentInstance     engine         = (ComponentInstance) GetControlReference( theControl);
    short                brightness     = GetControlValue( theControl );

    //--- Set the brightness. Since we can't pass back errors, just ignore any error
    ContrastEngineSetBrightness( engine, brightness );

    return;
}

//****************************************************************************************
// ContrastActionProc
//
//
//----------------------------------------------------------------------------------------
pascal void ContrastActionProc (ControlHandle theControl, short partCode)
{
#pragma unused (partCode)

    ComponentInstance     engine         = (ComponentInstance) GetControlReference( theControl);
    short                contrast     = GetControlValue( theControl );

    //--- Set the contrast. Since we can't pass back errors, just ignore any error
    ContrastEngineSetContrast( engine, contrast );

    return;
}

//****************************************************************************************
// BrightnessContrastNotify
//
//  This function is registered with Display Mgr (see SetupDialog) and is called
//  by Display Mgr whenever the contrast or the brightness changes on any display.
//  All we have to do is update our brightness and contrast sliders to
//  reflect this change. This way, if some other app changes the brightness/contrast
//  behind our backs (e.g. Monitors control panel), our sliders will pick up these
//  changes while the demo app is running.
//
//----------------------------------------------------------------------------------------
pascal void BrightnessContrastNotify (void* userData, short theMessage, void* notifyData)
{
    OurDMNotifyDataPtr        dataP = (OurDMNotifyDataPtr) userData;
    DependentNotifyPtr         dependentNotifyData = NULL;

    //--- If it's not a dependent notification, we don't care ------------
    if ( theMessage != kDMNotifyDependents )
        return;

    //--- We need the notification data for further analysis -------------
    dependentNotifyData = (DependentNotifyPtr)notifyData;
    if ( dependentNotifyData == NULL )
        return;

    //--- If it's not the display that we are interested in, we don't care
    if ( dependentNotifyData->notifyPortID != gOurDisplayID )
        return;

    //--- If it's not a brightness/contrast change or device reset, we don't care
    if ( dependentNotifyData->notifyType != kContrastChanged &&
         dependentNotifyData->notifyType != kBrightnessChanged &&
         dependentNotifyData->notifyType != kAVNotifyDeviceReset )
    {
        return;
    }

    //--- Update the sliders to reflect any changes. We have enough information
    //--- to only update either the brightness or the contrast slider, but
    //--- we'll be lazy and update both.
    UpdateSliders( dataP );

    return;
}